package com.biao.collection;


public class ArrayList {
    /*
    存放元素：有序
    线程是否安全 不安全
    Get Add方法
    时间复杂度 O（1）  是动态数组，不是链表

    数据结构：基于数组实现 类型object类型

    默认初始容量为10； 扩容是1.5倍
     */

    // 初始容量 10
    private static final int DEFAULT_CAPACITY = 10;

    // add 方法
    /*
    public boolean add(E e) {
        // size+1  然后调用 ensureCapacityInternal，所以size现在是1 了
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;  // 放到原来大小再 +1 的位置，也就是放到最后，也就是按顺序存放
        return true;
    }

    // ensureCapacityInternal 逻辑
    private void ensureCapacityInternal(int minCapacity) {  // minCapacity == 1
        // 添加元素前看集合是否是空的
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 设置初始大小为 10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);    // minCapacity 为10
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)   // 判断容量是否还够用
            grow(minC apacity);
    }

    private void grow(int minCapacity) {    // 容量管理方法
        // overflow-conscious code
        int oldCapacity = elementData.length;   // 初始容量是 0
        int newCapacity = oldCapacity + (oldCapacity >> 1);     // 扩容1.5：右移1位等于/2，加原来等于乘以1.5，但初始时候是0
        if (newCapacity - minCapacity < 0)      // 0 - 10 < 0
            newCapacity = minCapacity;      // newCapacity = 10
        if (newCapacity - MAX_ARRAY_SIZE > 0)      // 10 - 最大容量限制，肯定不会走
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);  // 初始化扩容完成：数据复制到新的数组
    }
     */


    // remove 方法
    /*
    // 循环遍历，判断当前元素是否是要删除的元素，调用fastRemove 删除
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)   // 判断是不是空数组
                            // 原数组， 原数组的开始位置， 目标数组，目标数组的开始位置， 要拷贝后面元素的个数长度
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 最后一个元素置空
        elementData[--size] = null; // clear to let GC do its work
    }
     */
}
